ஒருங்கிணைப்பில் தேர்ச்சி: உலகளாவிய பயன்பாடுகளுக்காக ஜாவாஸ்கிரிப்டில் ஒரு த்ரெட்-பாதுகாப்பான ட்ரை-ஐ உருவாக்குதல்

இன்றைய இணைக்கப்பட்ட உலகில், பயன்பாடுகளுக்கு வேகம் மட்டும் போதாது, அவை பதிலளிக்கும் திறனையும், பாரிய, ஒரே நேரத்தில் நிகழும் செயல்பாடுகளைக் கையாளும் திறனையும் கொண்டிருக்க வேண்டும். ஜாவாஸ்கிரிப்ட், உலாவியில் அதன் ஒற்றைத்-திரி (single-threaded) தன்மைக்கு பாரம்பரியமாக அறியப்பட்டாலும், உண்மையான இணைச்செயலாக்கத்தை (parallelism) சமாளிக்க சக்திவாய்ந்த அடிப்படைகளை வழங்கி, குறிப்பிடத்தக்க வகையில் பரிணாம வளர்ச்சியடைந்துள்ளது. பெரிய, மாறும் தரவுத்தொகுப்புகளை மல்டி-த்ரெட்டட் சூழலில் கையாளும்போது, குறிப்பாக ஒருங்கிணைப்பு சவால்களை எதிர்கொள்ளும் ஒரு பொதுவான தரவுக் கட்டமைப்பு ட்ரை (Trie) ஆகும், இது முன்னொட்டு மரம் (Prefix Tree) என்றும் அழைக்கப்படுகிறது.

ஒரு உலகளாவிய தன்னிரப்புச் சேவை, ஒரு நிகழ்நேர அகராதி, அல்லது ஒரு டைனமிக் IP ரூட்டிங் டேபிள் ஆகியவற்றை உருவாக்குவதை கற்பனை செய்து பாருங்கள். இங்கே மில்லியன் கணக்கான பயனர்கள் அல்லது சாதனங்கள் தொடர்ந்து தரவை வினவி மற்றும் புதுப்பித்து வருகின்றன. ஒரு நிலையான ட்ரை, முன்னொட்டு அடிப்படையிலான தேடல்களுக்கு நம்பமுடியாத அளவிற்கு திறமையானதாக இருந்தாலும், ஒரு ஒருங்கிணைந்த சூழலில் விரைவாக ஒரு இடையூறாக மாறுகிறது, இது ரேஸ் கண்டிஷன்கள் (race conditions) மற்றும் தரவு சிதைவுக்கு ஆளாகிறது. இந்த விரிவான வழிகாட்டி, ஜாவாஸ்கிரிப்ட் கன்கரென்ட் ட்ரை-ஐ எவ்வாறு உருவாக்குவது, SharedArrayBuffer மற்றும் Atomics-இன் சரியான பயன்பாட்டின் மூலம் அதை த்ரெட்-பாதுகாப்பானதாக மாற்றுவது எப்படி என்பதை ஆராயும், இது உலகளாவிய பார்வையாளர்களுக்காக வலுவான மற்றும் அளவிடக்கூடிய தீர்வுகளை செயல்படுத்த உதவும்.

ட்ரைகளைப் புரிந்துகொள்ளுதல்: முன்னொட்டு அடிப்படையிலான தரவுகளின் அடித்தளம்

ஒருங்கிணைப்பின் சிக்கல்களுக்குள் நாம் மூழ்குவதற்கு முன், ஒரு ட்ரை என்றால் என்ன, அது ஏன் மிகவும் மதிப்புமிக்கது என்பது பற்றிய திடமான புரிதலை நிறுவுவோம்.

ட்ரை என்றால் என்ன?

ட்ரை, 'retrieval' என்ற வார்த்தையிலிருந்து உருவானது ( உச்சரிப்பு "tree" அல்லது "try"), இது ஒரு வரிசைப்படுத்தப்பட்ட மரத் தரவுக் கட்டமைப்பாகும், இது ஒரு டைனமிக் செட் அல்லது அசோசியேட்டிவ் அரேயை சேமிக்கப் பயன்படுகிறது, இதில் கீகள் பொதுவாக சரங்களாக (strings) இருக்கும். ஒரு பைனரி தேடல் மரத்தைப் போலல்லாமல், நோட்கள் உண்மையான கீ-யை சேமிக்கும், ஒரு ட்ரையின் நோட்கள் கீ-களின் பகுதிகளை சேமிக்கின்றன, மேலும் மரத்தில் ஒரு நோட்டின் நிலை அதனுடன் தொடர்புடைய கீ-யை வரையறுக்கிறது.

• நோட்கள் மற்றும் எட்ஜ்கள்: ஒவ்வொரு நோடும் பொதுவாக ஒரு எழுத்தைக் குறிக்கிறது, மேலும் ரூட்டிலிருந்து ஒரு குறிப்பிட்ட நோட்டிற்கான பாதை ஒரு முன்னொட்டை உருவாக்குகிறது.
• சைல்டுகள்: ஒவ்வொரு நோடும் அதன் சைல்டுகளுக்கான குறிப்புகளைக் கொண்டுள்ளது, பொதுவாக ஒரு அரே அல்லது மேப்பில், அங்கு இன்டெக்ஸ்/கீ ஒரு வரிசையில் அடுத்த எழுத்தைக் குறிக்கிறது.
• டெர்மினல் கொடி: அந்த நோட்டிற்கு வழிவகுக்கும் பாதை ஒரு முழுமையான வார்த்தையைக் குறிக்கிறது என்பதைக் குறிக்க, நோட்களில் 'டெர்மினல்' அல்லது 'isWord' கொடியும் இருக்கலாம்.

இந்தக் கட்டமைப்பு மிகவும் திறமையான முன்னொட்டு அடிப்படையிலான செயல்பாடுகளை அனுமதிக்கிறது, இது சில பயன்பாட்டு நிகழ்வுகளுக்கு ஹாஷ் டேபிள்கள் அல்லது பைனரி தேடல் மரங்களை விட மேன்மையானதாக ஆக்குகிறது.

ட்ரை-களுக்கான பொதுவான பயன்பாட்டு நிகழ்வுகள்

சரம் தரவைக் கையாளுவதில் ட்ரை-களின் செயல்திறன் பல்வேறு பயன்பாடுகளில் அவற்றை ഒഴிக்க முடியாததாக ஆக்குகிறது:

• தன்னிரப்பு மற்றும் டைப்-அஹெட் பரிந்துரைகள்: ஒருவேளை மிகவும் பிரபலமான பயன்பாடு இதுவாக இருக்கலாம். கூகிள் போன்ற தேடுபொறிகள், கோட் எடிட்டர்கள் (IDEs), அல்லது நீங்கள் தட்டச்சு செய்யும்போது பரிந்துரைகளை வழங்கும் மெசேஜிங் செயலிகளை நினைத்துப் பாருங்கள். ஒரு ட்ரை ஒரு கொடுக்கப்பட்ட முன்னொட்டுடன் தொடங்கும் அனைத்து வார்த்தைகளையும் விரைவாகக் கண்டுபிடிக்க முடியும்.
  • உலகளாவிய எடுத்துக்காட்டு: ஒரு சர்வதேச மின்-வணிகத் தளத்திற்காக டஜன் கணக்கான மொழிகளில் நிகழ்நேர, உள்ளூர்மயமாக்கப்பட்ட தன்னிரப்புப் பரிந்துரைகளை வழங்குதல்.
• எழுத்துப்பிழை சரிபார்ப்பான்கள்: சரியாக உச்சரிக்கப்பட்ட வார்த்தைகளின் அகராதியைச் சேமிப்பதன் மூலம், ஒரு ட்ரை ஒரு வார்த்தை இருக்கிறதா என்பதை திறமையாகச் சரிபார்க்கலாம் அல்லது முன்னொட்டுகளின் அடிப்படையில் மாற்று வழிகளைப் பரிந்துரைக்கலாம்.
  • உலகளாவிய எடுத்துக்காட்டு: ஒரு உலகளாவிய உள்ளடக்க உருவாக்கும் கருவியில் பல்வேறு மொழியியல் உள்ளீடுகளுக்கு சரியான எழுத்துப்பிழையை உறுதி செய்தல்.
• IP ரூட்டிங் டேபிள்கள்: நீளமான-முன்னொட்டுப் பொருத்தத்திற்கு ட்ரை-கள் சிறப்பானவை, இது ஒரு IP முகவரிக்கான மிகவும் குறிப்பிட்ட பாதையைத் தீர்மானிக்க நெட்வொர்க் ரூட்டிங்கில் அடிப்படையானது.
  • உலகளாவிய எடுத்துக்காட்டு: பரந்த சர்வதேச நெட்வொர்க்குகளில் தரவு பாக்கெட் ரூட்டிங்கை மேம்படுத்துதல்.
• அகராதித் தேடல்: வார்த்தைகள் மற்றும் அவற்றின் வரையறைகளை வேகமாகத் தேடுதல்.
  • உலகளாவிய எடுத்துக்காட்டு: நூறாயிரக்கணக்கான வார்த்தைகளில் விரைவான தேடல்களை ஆதரிக்கும் ஒரு பன்மொழி அகராதியை உருவாக்குதல்.
• பயோ இன்ஃபர்மேட்டிக்ஸ்: DNA மற்றும் RNA வரிசைகளில் பேட்டர்ன் பொருத்தத்திற்குப் பயன்படுத்தப்படுகிறது, இங்கு நீண்ட சரங்கள் பொதுவானவை.
  • உலகளாவிய எடுத்துக்காட்டு: உலகெங்கிலும் உள்ள ஆராய்ச்சி நிறுவனங்களால் பங்களிக்கப்பட்ட மரபணுத் தரவுகளை பகுப்பாய்வு செய்தல்.

ஜாவாஸ்கிரிப்டில் ஒருங்கிணைப்பு சவால்

ஜாவாஸ்கிரிப்ட் ஒற்றைத்-திரி கொண்டது என்ற அதன் புகழ் பெரும்பாலும் அதன் முக்கிய செயலாக்கச் சூழலுக்கு, குறிப்பாக வலை உலாவிகளில் உண்மையானது. இருப்பினும், நவீன ஜாவாஸ்கிரிப்ட் இணைச்செயலாக்கத்தை அடைய சக்திவாய்ந்த வழிமுறைகளை வழங்குகிறது, அதனுடன், ஒருங்கிணைந்த நிரலாக்கத்தின் கிளாசிக் சவால்களையும் அறிமுகப்படுத்துகிறது.

ஜாவாஸ்கிரிப்டின் ஒற்றைத்-திரி தன்மை (மற்றும் அதன் வரம்புகள்)

மெயின் த்ரெட்டில் உள்ள ஜாவாஸ்கிரிப்ட் எஞ்சின் ஒரு ஈவன்ட் லூப் மூலம் பணிகளை வரிசையாகச் செயல்படுத்துகிறது. இந்த மாதிரி வலை மேம்பாட்டின் பல அம்சங்களை எளிதாக்குகிறது, டெட்லாக்குகள் போன்ற பொதுவான ஒருங்கிணைப்பு சிக்கல்களைத் தடுக்கிறது. இருப்பினும், கணினி ரீதியாகத் தீவிரமான பணிகளுக்கு, இது UI பதிலளிக்காமல் போவதற்கும் மோசமான பயனர் அனுபவத்திற்கும் வழிவகுக்கும்.

வெப் வொர்க்கர்களின் எழுச்சி: உலாவியில் உண்மையான ஒருங்கிணைப்பு

வெப் வொர்க்கர்கள் ஒரு வலைப்பக்கத்தின் முக்கிய செயலாக்கத் திரியிலிருந்து தனித்தனியாக, பின்னணித் திரிகளில் ஸ்கிரிப்ட்களை இயக்க ஒரு வழியை வழங்குகின்றன. இதன் பொருள், நீண்ட நேரம் இயங்கும், CPU-சார்ந்த பணிகளை ஆஃப்லோட் செய்யலாம், UI-ஐ பதிலளிக்கும் விதமாக வைத்திருக்கலாம். தரவு பொதுவாக மெயின் த்ரெட் மற்றும் வொர்க்கர்களுக்கு இடையில், அல்லது வொர்க்கர்களுக்கு இடையில், ஒரு மெசேஜ் பாஸிங் மாடல் (postMessage()) ஐப் பயன்படுத்திப் பகிரப்படுகிறது.

• மெசேஜ் பாஸிங்: திரிகளுக்கு இடையில் அனுப்பப்படும்போது தரவு 'structured cloned' (நகலெடுக்கப்படுகிறது). சிறிய மெசேஜ்களுக்கு, இது திறமையானது. இருப்பினும், மில்லியன் கணக்கான நோட்களைக் கொண்டிருக்கக்கூடிய ஒரு ட்ரை போன்ற பெரிய தரவுக் கட்டமைப்புகளுக்கு, முழு கட்டமைப்பையும் மீண்டும் மீண்டும் நகலெடுப்பது தாங்க முடியாத அளவிற்கு விலை உயர்ந்ததாக மாறும், இது ஒருங்கிணைப்பின் நன்மைகளை மறுக்கிறது.
  • சிந்தியுங்கள்: ஒரு ட்ரை ஒரு முக்கிய மொழிக்கான அகராதித் தரவைக் கொண்டிருந்தால், ஒவ்வொரு வொர்க்கர் தொடர்புக்கும் அதை நகலெடுப்பது திறமையற்றது.

பிரச்சனை: மாற்றக்கூடிய பகிரப்பட்ட நிலை மற்றும் ரேஸ் கண்டிஷன்கள்

பல திரிகள் (வெப் வொர்க்கர்கள்) ஒரே தரவுக் கட்டமைப்பை அணுகவும் மாற்றவும் தேவைப்படும்போது, மற்றும் அந்த தரவுக் கட்டமைப்பு மாற்றக்கூடியதாக இருக்கும்போது, ரேஸ் கண்டிஷன்கள் ஒரு தீவிரமான கவலையாக மாறுகின்றன. ஒரு ட்ரை, அதன் தன்மையால், மாற்றக்கூடியது: வார்த்தைகள் செருகப்படுகின்றன, தேடப்படுகின்றன, மற்றும் சில நேரங்களில் நீக்கப்படுகின்றன. சரியான ஒத்திசைவு இல்லாமல், ஒருங்கிணைந்த செயல்பாடுகள் பின்வருவனவற்றிற்கு வழிவகுக்கும்:

• தரவு சிதைவு: ஒரே எழுத்துக்கு ஒரு புதிய நோட்டைச் செருக ஒரே நேரத்தில் முயற்சிக்கும் இரண்டு வொர்க்கர்கள் ஒருவருக்கொருவர் மாற்றங்களை மேலெழுதலாம், இது ஒரு முழுமையற்ற அல்லது தவறான ட்ரைக்கு வழிவகுக்கும்.
• பொருந்தாத ரீட்கள்: ஒரு வொர்க்கர் பகுதியளவு புதுப்பிக்கப்பட்ட ட்ரை-ஐப் படிக்கலாம், இது தவறான தேடல் முடிவுகளுக்கு வழிவகுக்கும்.
• இழந்த புதுப்பிப்புகள்: ஒரு வொர்க்கரின் மாற்றம் மற்றொரு வொர்க்கர் முதல் மாற்றத்தை ஒப்புக் கொள்ளாமல் மேலெழுதினால் முற்றிலும் இழக்கப்படலாம்.

இதனால்தான் ஒரு நிலையான, ஆப்ஜெக்ட் அடிப்படையிலான ஜாவாஸ்கிரிப்ட் ட்ரை, ஒரு ஒற்றைத்-திரி சூழலில் செயல்பட்டாலும், வெப் வொர்க்கர்கள் முழுவதும் நேரடியாகப் பகிர்வதற்கும் மாற்றுவதற்கும் முற்றிலும் பொருத்தமற்றது. தீர்வு வெளிப்படையான நினைவக மேலாண்மை மற்றும் அணு செயல்பாடுகளில் உள்ளது.

த்ரெட் பாதுகாப்பை அடைதல்: ஜாவாஸ்கிரிப்டின் ஒருங்கிணைப்புப் பிரிமிட்டிவ்கள்

மெசேஜ் பாஸிங்கின் வரம்புகளைக் கடந்து, உண்மையான த்ரெட்-பாதுகாப்பான பகிரப்பட்ட நிலையை செயல்படுத்த, ஜாவாஸ்கிரிப்ட் சக்திவாய்ந்த குறைந்த-நிலை பிரிமிட்டிவ்களை அறிமுகப்படுத்தியது: SharedArrayBuffer மற்றும் Atomics.

SharedArrayBuffer-ஐ அறிமுகப்படுத்துதல்

SharedArrayBuffer என்பது ஒரு நிலையான-நீள மூல பைனரி தரவு பஃபர் ஆகும், இது ArrayBuffer-ஐப் போன்றது, ஆனால் ஒரு முக்கியமான வேறுபாட்டுடன்: அதன் உள்ளடக்கங்களை பல வெப் வொர்க்கர்களிடையே பகிரலாம். தரவை நகலெடுப்பதற்குப் பதிலாக, வொர்க்கர்கள் ஒரே அடிப்படை நினைவகத்தை நேரடியாக அணுகலாம் மற்றும் மாற்றலாம். இது பெரிய, சிக்கலான தரவுக் கட்டமைப்புகளுக்கான தரவுப் பரிமாற்றத்தின் மேல்சுமையை நீக்குகிறது.

• பகிரப்பட்ட நினைவகம்: ஒரு SharedArrayBuffer என்பது ஒரு உண்மையான நினைவகப் பகுதியாகும், அதை அனைத்து குறிப்பிட்ட வெப் வொர்க்கர்களும் படிக்கவும் எழுதவும் முடியும்.
• குளோனிங் இல்லை: நீங்கள் ஒரு SharedArrayBuffer-ஐ ஒரு வெப் வொர்க்கருக்கு அனுப்பும்போது, அதே நினைவக இடத்திற்கான ஒரு குறிப்பு அனுப்பப்படுகிறது, ஒரு நகல் அல்ல.
• பாதுகாப்புக் கருத்தாய்வுகள்: சாத்தியமான ஸ்பெக்டர்-பாணி தாக்குதல்கள் காரணமாக, SharedArrayBuffer-க்கு குறிப்பிட்ட பாதுகாப்புத் தேவைகள் உள்ளன. வலை உலாவிகளுக்கு, இது பொதுவாக Cross-Origin-Opener-Policy (COOP) மற்றும் Cross-Origin-Embedder-Policy (COEP) HTTP ஹெடர்களை same-origin அல்லது credentialless என்று அமைப்பதை உள்ளடக்கியது. இது உலகளாவிய வரிசைப்படுத்தலுக்கு ஒரு முக்கியமான புள்ளியாகும், ஏனெனில் சர்வர் கட்டமைப்புகள் புதுப்பிக்கப்பட வேண்டும். Node.js சூழல்கள் (worker_threads-ஐப் பயன்படுத்தி) இந்த அதே உலாவி-குறிப்பிட்ட கட்டுப்பாடுகளைக் கொண்டிருக்கவில்லை.

ஒரு SharedArrayBuffer மட்டும், இருப்பினும், ரேஸ் கண்டிஷன் பிரச்சனையைத் தீர்க்காது. இது பகிரப்பட்ட நினைவகத்தை வழங்குகிறது, ஆனால் ஒத்திசைவு வழிமுறைகளை அல்ல.

Atomics-இன் சக்தி

Atomics என்பது பகிரப்பட்ட நினைவகத்திற்கான அணு செயல்பாடுகளை வழங்கும் ஒரு குளோபல் ஆப்ஜெக்ட் ஆகும். 'அணு' என்றால், எந்தவொரு பிற திரியாலும் குறுக்கிடப்படாமல் செயல்பாடு முழுமையாக நிறைவடையும் என்று உத்தரவாதம் அளிக்கப்படுகிறது. இது பல வொர்க்கர்கள் ஒரு SharedArrayBuffer-க்குள் ஒரே நினைவக இடங்களை அணுகும்போது தரவு ஒருமைப்பாட்டை உறுதி செய்கிறது.

ஒரு கன்கரென்ட் ட்ரை-ஐ உருவாக்க அவசியமான முக்கிய Atomics முறைகள் பின்வருமாறு:

• Atomics.load(typedArray, index): ஒரு SharedArrayBuffer ஆல் ஆதரிக்கப்படும் ஒரு TypedArray இல் ஒரு குறிப்பிட்ட இன்டெக்ஸில் உள்ள மதிப்பை அணுரீதியாக ஏற்றுகிறது.
  • பயன்பாடு: நோட் பண்புகளை (எ.கா., சைல்ட் பாயிண்டர்கள், கேரக்டர் கோட்கள், டெர்மினல் கொடிகள்) குறுக்கீடு இல்லாமல் படிக்க.
• Atomics.store(typedArray, index, value): ஒரு குறிப்பிட்ட இன்டெக்ஸில் ஒரு மதிப்பை அணுரீதியாக சேமிக்கிறது.
  • பயன்பாடு: புதிய நோட் பண்புகளை எழுத.
• Atomics.add(typedArray, index, value): ஒரு குறிப்பிட்ட இன்டெக்ஸில் உள்ள தற்போதைய மதிப்புடன் ஒரு மதிப்பை அணுரீதியாகச் சேர்த்து, பழைய மதிப்பைத் திருப்பித் தருகிறது. கவுண்டர்களுக்கு பயனுள்ளது (எ.கா., ஒரு குறிப்பு எண்ணிக்கையை அல்லது 'அடுத்து கிடைக்கும் நினைவக முகவரி' பாயிண்டரை அதிகரித்தல்).
• Atomics.compareExchange(typedArray, index, expectedValue, replacementValue): இது ஒருங்கிணைந்த தரவுக் கட்டமைப்புகளுக்கான மிகவும் சக்திவாய்ந்த அணு செயல்பாடு என்று வாதிடலாம். இது index-இல் உள்ள மதிப்பு expectedValue உடன் பொருந்துகிறதா என்பதை அணுரீதியாகச் சரிபார்க்கிறது. அது பொருந்தினால், அது மதிப்பை replacementValue உடன் மாற்றி, பழைய மதிப்பைத் திருப்பித் தருகிறது (அது expectedValue ஆக இருந்தது). அது பொருந்தவில்லை என்றால், எந்த மாற்றமும் ஏற்படாது, அது index-இல் உள்ள உண்மையான மதிப்பைத் திருப்பித் தருகிறது.
  • பயன்பாடு: பூட்டுகளை (ஸ்பின்லாக்குகள் அல்லது மியூட்டெக்ஸ்கள்), ஆப்டிமிஸ்டிக் ஒருங்கிணைப்பை செயல்படுத்துதல், அல்லது ஒரு மாற்றம் எதிர்பார்க்கப்பட்ட நிலையில் மட்டுமே நிகழ்கிறது என்பதை உறுதி செய்தல். புதிய நோட்களை உருவாக்குவதற்கோ அல்லது பாயிண்டர்களைப் பாதுகாப்பாகப் புதுப்பிப்பதற்கோ இது முக்கியமானது.
• Atomics.wait(typedArray, index, value, [timeout]) மற்றும் Atomics.notify(typedArray, index, [count]): இவை மேலும் மேம்பட்ட ஒத்திசைவு பேட்டர்ன்களுக்குப் பயன்படுத்தப்படுகின்றன, வொர்க்கர்களை ஒரு குறிப்பிட்ட நிபந்தனைக்காக தடுத்து காத்திருக்க அனுமதிக்கிறது, பின்னர் அது மாறும்போது அறிவிக்கப்படும். தயாரிப்பாளர்-நுகர்வோர் பேட்டர்ன்கள் அல்லது சிக்கலான பூட்டுதல் வழிமுறைகளுக்குப் பயனுள்ளது.

பகிரப்பட்ட நினைவகத்திற்கான SharedArrayBuffer மற்றும் ஒத்திசைவுக்கான Atomics ஆகியவற்றின் ஒருங்கிணைப்பு, ஜாவாஸ்கிரிப்டில் நமது கன்கரென்ட் ட்ரை போன்ற சிக்கலான, த்ரெட்-பாதுகாப்பான தரவுக் கட்டமைப்புகளை உருவாக்கத் தேவையான அடித்தளத்தை வழங்குகிறது.

SharedArrayBuffer மற்றும் Atomics உடன் ஒரு கன்கரென்ட் ட்ரை-ஐ வடிவமைத்தல்

ஒரு கன்கரென்ட் ட்ரை-ஐ உருவாக்குவது என்பது ஒரு ஆப்ஜெக்ட்-சார்ந்த ட்ரை-ஐ ஒரு பகிரப்பட்ட நினைவகக் கட்டமைப்பாக மாற்றுவது மட்டுமல்ல. நோட்கள் எவ்வாறு குறிப்பிடப்படுகின்றன மற்றும் செயல்பாடுகள் எவ்வாறு ஒத்திசைக்கப்படுகின்றன என்பதில் ஒரு அடிப்படை மாற்றம் தேவைப்படுகிறது.

கட்டிடக்கலைக் கருத்தாய்வுகள்

ஒரு SharedArrayBuffer-இல் ட்ரை கட்டமைப்பைக் குறிப்பிடுதல்

நேரடி குறிப்புகளுடன் கூடிய ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்களுக்குப் பதிலாக, நமது ட்ரை நோட்கள் ஒரு SharedArrayBuffer-க்குள் தொடர்ச்சியான நினைவகத் தொகுதிகளாக குறிப்பிடப்பட வேண்டும். இதன் பொருள்:

• லீனியர் நினைவக ஒதுக்கீடு: நாம் பொதுவாக ஒரு ஒற்றை SharedArrayBuffer-ஐப் பயன்படுத்துவோம், அதை ஒரு பெரிய நிலையான-அளவு 'ஸ்லாட்கள்' அல்லது 'பக்கங்கள்' கொண்ட ஒரு அரேவாகக் கருதுவோம், இங்கு ஒவ்வொரு ஸ்லாட்டும் ஒரு ட்ரை நோட்டைக் குறிக்கிறது.
• இன்டெக்ஸ்களாக நோட் பாயிண்டர்கள்: மற்ற ஆப்ஜெக்ட்களுக்கான குறிப்புகளைச் சேமிப்பதற்குப் பதிலாக, சைல்ட் பாயிண்டர்கள் அதே SharedArrayBuffer-க்குள் மற்றொரு நோட்டின் தொடக்க நிலைக்குச் சுட்டிக்காட்டும் எண் இன்டெக்ஸ்களாக இருக்கும்.
• நிலையான-அளவு நோட்கள்: நினைவக நிர்வாகத்தை எளிதாக்க, ஒவ்வொரு ட்ரை நோடும் ஒரு முன்வரையறுக்கப்பட்ட எண்ணிக்கையிலான பைட்டுகளை ஆக்கிரமிக்கும். இந்த நிலையான அளவு அதன் எழுத்து, சைல்ட் பாயிண்டர்கள் மற்றும் டெர்மினல் கொடிக்கு இடமளிக்கும்.

ஒரு SharedArrayBuffer-க்குள் ஒரு எளிமைப்படுத்தப்பட்ட நோட் கட்டமைப்பைக் கருத்தில் கொள்வோம். ஒவ்வொரு நோடும் முழு எண்களின் ஒரு அரேவாக இருக்கலாம் (எ.கா., Int32Array அல்லது Uint32Array வியூக்கள் SharedArrayBuffer மீது), அங்கு:

• இன்டெக்ஸ் 0: `characterCode` (எ.கா., இந்த நோட் குறிக்கும் எழுத்தின் ASCII/Unicode மதிப்பு, அல்லது ரூட்டிற்கு 0).
• இன்டெக்ஸ் 1: `isTerminal` (false-க்கு 0, true-க்கு 1).
• இன்டெக்ஸ் 2 முதல் N வரை: `children[0...25]` (அல்லது பரந்த எழுத்துத் தொகுப்புகளுக்கு மேலும்), இங்கு ஒவ்வொரு மதிப்பும் SharedArrayBuffer-க்குள் ஒரு சைல்ட் நோட்டிற்கான ஒரு இன்டெக்ஸ் ஆகும், அல்லது அந்த எழுத்திற்கு சைல்ட் இல்லை என்றால் 0.
• பஃபரில் எங்காவது ஒரு `nextFreeNodeIndex` பாயிண்டர் (அல்லது வெளிப்புறமாக நிர்வகிக்கப்படுகிறது) புதிய நோட்களை ஒதுக்க.

எடுத்துக்காட்டு: ஒரு நோட் 30 `Int32` ஸ்லாட்டுகளை ஆக்கிரமித்தால், மற்றும் நமது SharedArrayBuffer ஒரு Int32Array ஆகப் பார்க்கப்பட்டால், இன்டெக்ஸ் `i`-இல் உள்ள நோட் `i * 30`-இல் தொடங்குகிறது.

இலவச நினைவகத் தொகுதிகளை நிர்வகித்தல்

புதிய நோட்கள் செருகப்படும்போது, நாம் இடத்தை ஒதுக்க வேண்டும். ஒரு எளிய அணுகுமுறை, SharedArrayBuffer-இல் அடுத்த கிடைக்கக்கூடிய இலவச ஸ்லாட்டிற்கான ஒரு பாயிண்டரை பராமரிப்பதாகும். இந்த பாயிண்டர் தானாகவே அணுரீதியாகப் புதுப்பிக்கப்பட வேண்டும்.

த்ரெட்-பாதுகாப்பான செருகலை செயல்படுத்துதல் (`insert` செயல்பாடு)

செருகல் என்பது மிகவும் சிக்கலான செயல்பாடாகும், ஏனெனில் இது ட்ரை கட்டமைப்பை மாற்றுவது, சாத்தியமான புதிய நோட்களை உருவாக்குவது மற்றும் பாயிண்டர்களைப் புதுப்பிப்பதை உள்ளடக்கியது. நிலைத்தன்மையை உறுதி செய்ய இங்குதான் Atomics.compareExchange() முக்கியமாகிறது.

"apple" போன்ற ஒரு வார்த்தையைச் செருகுவதற்கான படிகளை கோடிட்டுக் காட்டுவோம்:

த்ரெட்-பாதுகாப்பான செருகலுக்கான கருத்தியல் படிகள்:

1. ரூட்டில் தொடங்குங்கள்: ரூட் நோட்டிலிருந்து (இன்டெக்ஸ் 0-இல்) பயணிக்கத் தொடங்குங்கள். ரூட் பொதுவாக ஒரு எழுத்தை தானாகவே குறிப்பதில்லை.
2. எழுத்து வாரியாகப் பயணிக்கவும்: வார்த்தையில் உள்ள ஒவ்வொரு எழுத்திற்கும் (எ.கா., 'a', 'p', 'p', 'l', 'e'):
   1. சைல்ட் இன்டெக்ஸை தீர்மானிக்கவும்: தற்போதைய நோட்டின் சைல்ட் பாயிண்டர்களுக்குள் தற்போதைய எழுத்திற்குப் பொருந்தும் இன்டெக்ஸைக் கணக்கிடுங்கள். (எ.கா., `children[char.charCodeAt(0) - 'a'.charCodeAt(0)]`).
   2. சைல்ட் பாயிண்டரை அணுரீதியாக ஏற்றவும்: சாத்தியமான சைல்ட் நோட்டின் தொடக்க இன்டெக்ஸைப் பெற Atomics.load(typedArray, current_node_child_pointer_index)-ஐப் பயன்படுத்தவும்.
   3. சைல்ட் இருக்கிறதா என்று சரிபார்க்கவும்:
      • ஏற்றப்பட்ட சைல்ட் பாயிண்டர் 0 ஆக இருந்தால் (சைல்ட் இல்லை): இங்குதான் நாம் ஒரு புதிய நோட்டை உருவாக்க வேண்டும்.
        1. புதிய நோட் இன்டெக்ஸை ஒதுக்கவும்: புதிய நோட்டிற்கான ஒரு புதிய தனித்துவமான இன்டெக்ஸை அணுரீதியாகப் பெறவும். இது பொதுவாக ஒரு 'அடுத்து கிடைக்கும் நோட்' கவுண்டரின் அணுரீதியான அதிகரிப்பை உள்ளடக்கியது (எ.கா., `newNodeIndex = Atomics.add(typedArray, NEXT_FREE_NODE_INDEX_OFFSET, NODE_SIZE)`). திருப்பித் தரப்பட்ட மதிப்பு, அதிகரிப்பதற்கு முந்தைய *பழைய* மதிப்பு, அதுவே நமது புதிய நோட்டின் தொடக்க முகவரி.
        2. புதிய நோட்டைத் துவக்கவும்: புதிதாக ஒதுக்கப்பட்ட நோட்டின் நினைவகப் பகுதிக்கு எழுத்துக் குறியீடு மற்றும் `isTerminal = 0`-ஐ Atomics.store()-ஐப் பயன்படுத்தி எழுதவும்.
        3. புதிய நோட்டை இணைக்க முயற்சிக்கவும்: இது த்ரெட் பாதுகாப்பிற்கான முக்கியமான படி. Atomics.compareExchange(typedArray, current_node_child_pointer_index, 0, newNodeIndex)-ஐப் பயன்படுத்தவும்.
           • compareExchange 0-ஐத் திருப்பினால் (அதாவது நாம் அதை இணைக்க முயன்றபோது சைல்ட் பாயிண்டர் உண்மையில் 0 ஆக இருந்தது), நமது புதிய நோட் வெற்றிகரமாக இணைக்கப்பட்டுள்ளது. புதிய நோட்டிற்கு `current_node` ஆகத் தொடரவும்.
           • compareExchange ஒரு பூஜ்ஜியமற்ற மதிப்பைத் திருப்பினால் (அதாவது மற்றொரு வொர்க்கர் இந்த எழுத்திற்கு ஒரு நோட்டை இடையில் வெற்றிகரமாக இணைத்துவிட்டது), நமக்கு ஒரு மோதல் உள்ளது. நாம் புதிதாக உருவாக்கிய நோட்டை *நிராகரிக்கிறோம்* (அல்லது ஒரு ஃப்ரீ லிஸ்டில் அதை மீண்டும் சேர்க்கிறோம், நாம் ஒரு பூலை நிர்வகித்தால்) மற்றும் பதிலாக compareExchange ஆல் திருப்பித் தரப்பட்ட இன்டெக்ஸை நமது `current_node` ஆகப் பயன்படுத்துகிறோம். நாம் திறம்பட போட்டியில் 'தோற்று' வெற்றியாளரால் உருவாக்கப்பட்ட நோட்டைப் பயன்படுத்துகிறோம்.
      • ஏற்றப்பட்ட சைல்ட் பாயிண்டர் பூஜ்ஜியமற்றதாக இருந்தால் (சைல்ட் ஏற்கனவே உள்ளது): வெறுமனே `current_node`-ஐ ஏற்றப்பட்ட சைல்ட் இன்டெக்ஸுக்கு அமைத்து, அடுத்த எழுத்திற்குத் தொடரவும்.
3. டெர்மினலாகக் குறிக்கவும்: அனைத்து எழுத்துகளும் செயலாக்கப்பட்டதும், இறுதி நோட்டின் `isTerminal` கொடியை அணுரீதியாக 1-க்கு Atomics.store()-ஐப் பயன்படுத்தி அமைக்கவும்.

Atomics.compareExchange() உடனான இந்த ஆப்டிமிஸ்டிக் லாக்கிங் உத்தி இன்றியமையாதது. வெளிப்படையான மியூட்டெக்ஸ்களைப் பயன்படுத்துவதற்குப் பதிலாக (இதை உருவாக்க Atomics.wait/`notify` உதவலாம்), இந்த அணுகுமுறை ஒரு மாற்றத்தைச் செய்ய முயற்சிக்கிறது, ஒரு மோதல் கண்டறியப்பட்டால் மட்டுமே பின்வாங்குகிறது அல்லது மாற்றியமைக்கிறது, இது பல ஒருங்கிணைந்த சூழ்நிலைகளுக்குத் திறமையானதாக ஆக்குகிறது.

விளக்கமான (எளிமைப்படுத்தப்பட்ட) செருகலுக்கான போலிக்குறியீடு:

const NODE_SIZE = 30; // எடுத்துக்காட்டு: மெட்டாடேட்டாவிற்கு 2 + சைல்டுகளுக்கு 28
const CHARACTER_CODE_OFFSET = 0;
const IS_TERMINAL_OFFSET = 1;
const CHILDREN_OFFSET = 2;
const NEXT_FREE_NODE_INDEX_OFFSET = 0; // பஃபரின் தொடக்கத்திலேயே சேமிக்கப்படுகிறது

// 'sharedBuffer' என்பது SharedArrayBuffer மீது உள்ள ஒரு Int32Array வியூ என்று ধরেக்கொள்வோம்
function insertWord(word, sharedBuffer) {
    let currentNodeIndex = NODE_SIZE; // ரூட் நோட், ஃப்ரீ பாயிண்டருக்குப் பிறகு தொடங்குகிறது

    for (let i = 0; i < word.length; i++) {
        const charCode = word.charCodeAt(i);
        const childIndexInNode = charCode - 'a'.charCodeAt(0) + CHILDREN_OFFSET;
        const childPointerOffset = currentNodeIndex + childIndexInNode;

        let nextNodeIndex = Atomics.load(sharedBuffer, childPointerOffset);

        if (nextNodeIndex === 0) {
            // சைல்ட் இல்லை, ஒன்றை உருவாக்க முயற்சிக்கவும்
            const allocatedNodeIndex = Atomics.add(sharedBuffer, NEXT_FREE_NODE_INDEX_OFFSET, NODE_SIZE);

            // புதிய நோட்டைத் துவக்கவும்
            Atomics.store(sharedBuffer, allocatedNodeIndex + CHARACTER_CODE_OFFSET, charCode);
            Atomics.store(sharedBuffer, allocatedNodeIndex + IS_TERMINAL_OFFSET, 0);
            // அனைத்து சைல்ட் பாயிண்டர்களும் இயல்பாக 0 ஆக இருக்கும்
            for (let k = 0; k < NODE_SIZE - CHILDREN_OFFSET; k++) {
                Atomics.store(sharedBuffer, allocatedNodeIndex + CHILDREN_OFFSET + k, 0);
            }

            // நமது புதிய நோட்டை அணுரீதியாக இணைக்க முயற்சிக்கவும்
            const actualOldValue = Atomics.compareExchange(sharedBuffer, childPointerOffset, 0, allocatedNodeIndex);

            if (actualOldValue === 0) {
                // நமது நோட்டை வெற்றிகரமாக இணைத்தோம், தொடரவும்
                nextNodeIndex = allocatedNodeIndex;
            } else {
                // மற்றொரு வொர்க்கர் ஒரு நோட்டை இணைத்துவிட்டது; அவர்களுடையதைப் பயன்படுத்தவும். நமது ஒதுக்கப்பட்ட நோட் இப்போது பயன்படுத்தப்படாது.
                // ஒரு உண்மையான அமைப்பில், நீங்கள் இங்கு ஒரு ஃப்ரீ லிஸ்டை மேலும் வலுவாக நிர்வகிப்பீர்கள்.
                // எளிமைக்காக, நாம் வெற்றியாளரின் நோட்டைப் பயன்படுத்துகிறோம்.
                nextNodeIndex = actualOldValue;
            }
        }
        currentNodeIndex = nextNodeIndex;
    }
    // இறுதி நோட்டை டெர்மினலாகக் குறிக்கவும்
    Atomics.store(sharedBuffer, currentNodeIndex + IS_TERMINAL_OFFSET, 1);
}

த்ரெட்-பாதுகாப்பான தேடலை செயல்படுத்துதல் (`search` மற்றும் `startsWith` செயல்பாடுகள்)

ஒரு வார்த்தையைத் தேடுவது அல்லது ஒரு கொடுக்கப்பட்ட முன்னொட்டுடன் உள்ள அனைத்து வார்த்தைகளையும் கண்டுபிடிப்பது போன்ற ரீட் செயல்பாடுகள் பொதுவாக எளிமையானவை, ஏனெனில் அவை கட்டமைப்பை மாற்றுவதை உள்ளடக்கவில்லை. இருப்பினும், அவை நிலையான, புதுப்பிக்கப்பட்ட மதிப்புகளைப் படிக்கின்றன என்பதை உறுதிப்படுத்த அணுரீதியான லோட்களைப் பயன்படுத்த வேண்டும், ஒருங்கிணைந்த ரைட்களிலிருந்து பகுதி ரீட்களைத் தவிர்க்க வேண்டும்.

த்ரெட்-பாதுகாப்பான தேடலுக்கான கருத்தியல் படிகள்:

1. ரூட்டில் தொடங்குங்கள்: ரூட் நோட்டில் தொடங்கவும்.
2. எழுத்து வாரியாகப் பயணிக்கவும்: தேடல் முன்னொட்டில் உள்ள ஒவ்வொரு எழுத்திற்கும்:
   1. சைல்ட் இன்டெக்ஸை தீர்மானிக்கவும்: எழுத்திற்கான சைல்ட் பாயிண்டர் ஆஃப்செட்டைக் கணக்கிடுங்கள்.
   2. சைல்ட் பாயிண்டரை அணுரீதியாக ஏற்றவும்: Atomics.load(typedArray, current_node_child_pointer_index)-ஐப் பயன்படுத்தவும்.
   3. சைல்ட் இருக்கிறதா என்று சரிபார்க்கவும்: ஏற்றப்பட்ட பாயிண்டர் 0 ஆக இருந்தால், வார்த்தை/முன்னொட்டு இல்லை. வெளியேறவும்.
   4. சைல்டுக்கு நகரவும்: அது இருந்தால், `current_node`-ஐ ஏற்றப்பட்ட சைல்ட் இன்டெக்ஸுக்குப் புதுப்பித்துத் தொடரவும்.
3. இறுதிச் சரிபார்ப்பு (`search`-க்கு): முழு வார்த்தையையும் கடந்த பிறகு, இறுதி நோட்டின் `isTerminal` கொடியை அணுரீதியாக ஏற்றவும். அது 1 ஆக இருந்தால், வார்த்தை உள்ளது; இல்லையெனில், அது ஒரு முன்னொட்டு மட்டுமே.
4. `startsWith`-க்கு: அடையப்பட்ட இறுதி நோட் முன்னொட்டின் முடிவைக் குறிக்கிறது. இந்த நோட்டிலிருந்து, ஒரு டெப்த்-ஃபர்ஸ்ட் தேடல் (DFS) அல்லது பிரெத்-ஃபர்ஸ்ட் தேடல் (BFS) அதன் துணை மரத்தில் உள்ள அனைத்து டெர்மினல் நோட்களையும் கண்டுபிடிக்கத் தொடங்கப்படலாம் (அணுரீதியான லோட்களைப் பயன்படுத்தி).

ரீட் செயல்பாடுகள் அடிப்படை நினைவகம் அணுரீதியாக அணுகப்படும் வரை இயல்பாகவே பாதுகாப்பானவை. ரைட்களின் போது உள்ள `compareExchange` தர்க்கம், எந்தவொரு செல்லுபடியாகாத பாயிண்டர்களும் நிறுவப்படவில்லை என்பதை உறுதி செய்கிறது, மேலும் ரைட் போது ஏற்படும் எந்த ரேஸும் ஒரு நிலையான (ஒரு வொர்க்கருக்கு சற்று தாமதமாக இருக்கலாம்) நிலைக்கு வழிவகுக்கிறது.

விளக்கமான (எளிமைப்படுத்தப்பட்ட) தேடலுக்கான போலிக்குறியீடு:

function searchWord(word, sharedBuffer) {
    let currentNodeIndex = NODE_SIZE;

    for (let i = 0; i < word.length; i++) {
        const charCode = word.charCodeAt(i);
        const childIndexInNode = charCode - 'a'.charCodeAt(0) + CHILDREN_OFFSET;
        const childPointerOffset = currentNodeIndex + childIndexInNode;

        const nextNodeIndex = Atomics.load(sharedBuffer, childPointerOffset);

        if (nextNodeIndex === 0) {
            return false; // எழுத்துப் பாதை இல்லை
        }
        currentNodeIndex = nextNodeIndex;
    }
    // இறுதி நோட் ஒரு டெர்மினல் வார்த்தையா என்பதைச் சரிபார்க்கவும்
    return Atomics.load(sharedBuffer, currentNodeIndex + IS_TERMINAL_OFFSET) === 1;
}

த்ரெட்-பாதுகாப்பான நீக்கலை செயல்படுத்துதல் (மேம்பட்டது)

ஒருங்கிணைந்த பகிரப்பட்ட நினைவகச் சூழலில் நீக்கம் குறிப்பிடத்தக்க வகையில் மிகவும் சவாலானது. அனுபவமற்ற நீக்கம் பின்வருவனவற்றிற்கு வழிவகுக்கும்:

• தொங்கும் பாயிண்டர்கள்: ஒரு வொர்க்கர் ஒரு நோட்டை நீக்கும்போது மற்றொருவர் அதற்குப் பயணித்தால், பயணிக்கும் வொர்க்கர் ஒரு செல்லுபடியாகாத பாயிண்டரைப் பின்பற்றலாம்.
• பொருந்தாத நிலை: பகுதி நீக்கங்கள் ட்ரை-ஐ ஒரு பயன்படுத்த முடியாத நிலையில் விடலாம்.
• நினைவகத் துண்டாக்கம்: நீக்கப்பட்ட நினைவகத்தைப் பாதுகாப்பாகவும் திறமையாகவும் மீட்டெடுப்பது சிக்கலானது.

நீக்கத்தைப் பாதுகாப்பாகக் கையாள பொதுவான உத்திகள் பின்வருமாறு:

• தருக்க ரீதியான நீக்கம் (குறித்தல்): நோட்களை உடல் ரீதியாக அகற்றுவதற்குப் பதிலாக, ஒரு `isDeleted` கொடியை அணுரீதியாக அமைக்கலாம். இது ஒருங்கிணைப்பை எளிதாக்குகிறது ஆனால் அதிக நினைவகத்தைப் பயன்படுத்துகிறது.
• குறிப்பு எண்ணுதல் / குப்பை சேகரிப்பு: ஒவ்வொரு நோடும் ஒரு அணு குறிப்பு எண்ணிக்கையை பராமரிக்கலாம். ஒரு நோட்டின் குறிப்பு எண்ணிக்கை பூஜ்ஜியமாகக் குறையும்போது, அது உண்மையிலேயே அகற்றுவதற்குத் தகுதியானது, அதன் நினைவகத்தை மீட்டெடுக்கலாம் (எ.கா., ஒரு ஃப்ரீ லிஸ்டில் சேர்க்கலாம்). இதற்கும் குறிப்பு எண்ணிக்கைகளுக்கு அணுரீதியான புதுப்பிப்புகள் தேவை.
• ரீட்-காப்பி-அப்டேட் (RCU): மிகவும் அதிக-ரீட், குறைந்த-ரைட் சூழ்நிலைகளுக்கு, ரைட்டர்கள் ட்ரையின் மாற்றப்பட்ட பகுதியின் ஒரு புதிய பதிப்பை உருவாக்கலாம், மற்றும் முடிந்ததும், புதிய பதிப்பிற்கான ஒரு பாயிண்டரை அணுரீதியாக மாற்றலாம். ரீட்கள் மாற்றம் முடியும் வரை பழைய பதிப்பில் தொடரும். ஒரு ட்ரை போன்ற ஒரு நுணுக்கமான தரவுக் கட்டமைப்பிற்கு இதை செயல்படுத்துவது சிக்கலானது ஆனால் வலுவான நிலைத்தன்மை உத்தரவாதங்களை வழங்குகிறது.

பல நடைமுறைப் பயன்பாடுகளுக்கு, குறிப்பாக அதிக செயல்வீதம் தேவைப்படுபவற்றுக்கு, ஒரு பொதுவான அணுகுமுறை ட்ரை-களை சேர்ப்பு-மட்டும் கொண்டதாக மாற்றுவது அல்லது தருக்க ரீதியான நீக்கத்தைப் பயன்படுத்துவது, சிக்கலான நினைவக மீட்டெடுப்பை குறைவான முக்கியமான நேரங்களுக்கு ஒத்திவைப்பது அல்லது அதை வெளிப்புறமாக நிர்வகிப்பது. உண்மையான, திறமையான, மற்றும் அணுரீதியான உடல் ரீதியான நீக்கலை செயல்படுத்துவது ஒருங்கிணைந்த தரவுக் கட்டமைப்புகளில் ஒரு ஆராய்ச்சி-நிலை பிரச்சனையாகும்.

நடைமுறைக் கருத்தாய்வுகள் மற்றும் செயல்திறன்

ஒரு கன்கரென்ட் ட்ரை-ஐ உருவாக்குவது என்பது சரியானது என்பதைப் பற்றியது மட்டுமல்ல; அது நடைமுறைச் செயல்திறன் மற்றும் பராமரிக்கக்கூடிய தன்மை பற்றியதும் ஆகும்.

நினைவக மேலாண்மை மற்றும் மேல்சுமை

• `SharedArrayBuffer` துவக்கம்: பஃபர் போதுமான அளவிற்கு முன்-ஒதுக்கீடு செய்யப்பட வேண்டும். நோட்களின் அதிகபட்ச எண்ணிக்கை மற்றும் அவற்றின் நிலையான அளவை மதிப்பிடுவது முக்கியமானது. ஒரு SharedArrayBuffer-ஐ டைனமிக்காக மறுஅளவிடுவது நேரடியானது அல்ல, பெரும்பாலும் ஒரு புதிய, பெரிய பஃபரை உருவாக்கி உள்ளடக்கங்களை நகலெடுப்பதை உள்ளடக்கியது, இது தொடர்ச்சியான செயல்பாட்டிற்கு பகிரப்பட்ட நினைவகத்தின் நோக்கத்தைத் தோற்கடிக்கிறது.
• இடத் திறன்: நிலையான-அளவு நோட்கள், நினைவக ஒதுக்கீடு மற்றும் பாயிண்டர் எண்கணிதத்தை எளிதாக்கினாலும், பல நோட்கள் சிதறிய சைல்ட் தொகுப்புகளைக் கொண்டிருந்தால் குறைந்த நினைவக-திறன் கொண்டதாக இருக்கலாம். இது எளிமைப்படுத்தப்பட்ட ஒருங்கிணைந்த நிர்வாகத்திற்கான ஒரு சமரசம்.
• கையேடு குப்பை சேகரிப்பு: ஒரு SharedArrayBuffer-க்குள் தானியங்கி குப்பை சேகரிப்பு இல்லை. நீக்கப்பட்ட நோட்களின் நினைவகம் நினைவகக் கசிவுகள் மற்றும் துண்டாக்கத்தைத் தவிர்க்க, வெளிப்படையாக நிர்வகிக்கப்பட வேண்டும், பெரும்பாலும் ஒரு ஃப்ரீ லிஸ்ட் மூலம். இது குறிப்பிடத்தக்க சிக்கலைச் சேர்க்கிறது.

செயல்திறன் அளவீடு

நீங்கள் எப்போது ஒரு கன்கரென்ட் ட்ரை-ஐத் தேர்ந்தெடுக்க வேண்டும்? இது எல்லா சூழ்நிலைகளுக்கும் ஒரு வெள்ளித் தோட்டா அல்ல.

• ஒற்றைத்-திரி vs. மல்டி-திரி: சிறிய தரவுத்தொகுப்புகள் அல்லது குறைந்த ஒருங்கிணைப்பிற்கு, மெயின் த்ரெட்டில் உள்ள ஒரு நிலையான ஆப்ஜெக்ட்-அடிப்படையிலான ட்ரை, வெப் வொர்க்கர் தொடர்பு அமைப்பு மற்றும் அணு செயல்பாடுகளின் மேல்சுமை காரணமாக இன்னும் வேகமாக இருக்கலாம்.
• அதிக ஒருங்கிணைந்த ரைட்/ரீட் செயல்பாடுகள்: உங்களிடம் ஒரு பெரிய தரவுத்தொகுப்பு, அதிக அளவிலான ஒருங்கிணைந்த ரைட் செயல்பாடுகள் (செருகல்கள், நீக்கல்கள்), மற்றும் பல ஒருங்கிணைந்த ரீட் செயல்பாடுகள் (தேடல்கள், முன்னொட்டுத் தேடல்கள்) இருக்கும்போது கன்கரென்ட் ட்ரை பிரகாசிக்கிறது. இது மெயின் த்ரெட்டிலிருந்து கனமான கணக்கீட்டை ஆஃப்லோட் செய்கிறது.
• `Atomics` மேல்சுமை: அணு செயல்பாடுகள், சரியானது என்பதற்கு அவசியமானவை என்றாலும், பொதுவாக அணு அல்லாத நினைவக அணுகல்களை விட மெதுவானவை. நன்மைகள் தனிப்பட்ட செயல்பாடுகளின் வேகத்திலிருந்து வருவதில்லை, மாறாக பல கோர்களில் இணைச் செயலாக்கத்திலிருந்து வருகின்றன. இணை வேக அதிகரிப்பு அணு மேல்சுமையை விட அதிகமாக உள்ளதா என்பதைத் தீர்மானிக்க உங்கள் குறிப்பிட்ட பயன்பாட்டு நிகழ்வை அளவிடுவது முக்கியம்.

பிழை கையாளுதல் மற்றும் வலுவான தன்மை

ஒருங்கிணைந்த நிரல்களை பிழைதிருத்தம் செய்வது notoriously கடினமானது. ரேஸ் கண்டிஷன்கள் கண்டுபிடிக்க முடியாதவையாகவும், தீர்மானிக்க முடியாதவையாகவும் இருக்கலாம். பல ஒருங்கிணைந்த வொர்க்கர்களுடன் கூடிய மன அழுத்த சோதனைகள் உட்பட விரிவான சோதனை அவசியம்.

• மறு முயற்சிகள்: `compareExchange` போன்ற செயல்பாடுகள் தோல்வியடைவது என்பது மற்றொரு வொர்க்கர் முதலில் அங்கு வந்துவிட்டது என்று பொருள். செருகல் போலிக்குறியீட்டில் காட்டப்பட்டுள்ளபடி, உங்கள் தர்க்கம் மீண்டும் முயற்சிக்க அல்லது மாற்றியமைக்கத் தயாராக இருக்க வேண்டும்.
• டைம்அவுட்கள்: மேலும் சிக்கலான ஒத்திசைவில், `Atomics.wait` ஒரு `notify` ஒருபோதும் வராவிட்டால் டெட்லாக்குகளைத் தடுக்க ஒரு டைம்அவுட்டை எடுக்கலாம்.

உலாவி மற்றும் சூழல் ஆதரவு

• வெப் வொர்க்கர்கள்: நவீன உலாவிகள் மற்றும் Node.js (`worker_threads`)-இல் பரவலாக ஆதரிக்கப்படுகிறது.
• `SharedArrayBuffer` & `Atomics`: அனைத்து முக்கிய நவீன உலாவிகள் மற்றும் Node.js-இல் ஆதரிக்கப்படுகிறது. இருப்பினும், குறிப்பிட்டுள்ளபடி, உலாவி சூழல்களுக்கு பாதுகாப்பு கவலைகள் காரணமாக SharedArrayBuffer-ஐ செயல்படுத்த குறிப்பிட்ட HTTP ஹெடர்கள் (COOP/COEP) தேவை. உலகளாவிய ரீச்சை நோக்கமாகக் கொண்ட வலைப் பயன்பாடுகளுக்கு இது ஒரு முக்கியமான வரிசைப்படுத்தல் விவரம்.
  • உலகளாவிய தாக்கம்: உலகெங்கிலும் உள்ள உங்கள் சர்வர் உள்கட்டமைப்பு இந்த ஹெடர்களைச் சரியாக அனுப்ப உள்ளமைக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும்.

பயன்பாட்டு நிகழ்வுகள் மற்றும் உலகளாவிய தாக்கம்

ஜாவாஸ்கிரிப்டில் த்ரெட்-பாதுகாப்பான, ஒருங்கிணைந்த தரவுக் கட்டமைப்புகளை உருவாக்கும் திறன், குறிப்பாக உலகளாவிய பயனர் தளத்திற்கு சேவை செய்யும் அல்லது பரந்த அளவிலான விநியோகிக்கப்பட்ட தரவைச் செயலாக்கும் பயன்பாடுகளுக்கு, சாத்தியக்கூறுகளின் ஒரு உலகத்தைத் திறக்கிறது.

• உலகளாவிய தேடல் & தன்னிரப்புத் தளங்கள்: ஒரு சர்வதேச தேடுபொறி அல்லது ஒரு மின்-வணிகத் தளத்தைக் கற்பனை செய்து பாருங்கள், அது தயாரிப்புப் பெயர்கள், இடங்கள், மற்றும் பயனர் வினவல்களுக்கு பல்வேறு மொழிகள் மற்றும் எழுத்துத் தொகுப்புகளில் அதி-வேக, நிகழ்நேர தன்னிரப்புப் பரிந்துரைகளை வழங்க வேண்டும். வெப் வொர்க்கர்களில் உள்ள ஒரு கன்கரென்ட் ட்ரை, பாரிய ஒருங்கிணைந்த வினவல்கள் மற்றும் டைனமிக் புதுப்பிப்புகளை (எ.கா., புதிய தயாரிப்புகள், பிரபலமான தேடல்கள்) மெயின் UI த்ரெட்டைத் தாமதப்படுத்தாமல் கையாள முடியும்.
• விநியோகிக்கப்பட்ட மூலங்களிலிருந்து நிகழ்நேரத் தரவுச் செயலாக்கம்: வெவ்வேறு கண்டங்களில் உள்ள சென்சார்களிடமிருந்து தரவைச் சேகரிக்கும் IoT பயன்பாடுகளுக்கு, அல்லது பல்வேறு பரிமாற்றங்களிலிருந்து சந்தைத் தரவு ஊட்டங்களைச் செயலாக்கும் நிதி அமைப்புகளுக்கு, ஒரு கன்கரென்ட் ட்ரை சரம் அடிப்படையிலான தரவு ஓடைகளை (எ.கா., சாதன ஐடிகள், பங்கு டிக்கர்கள்) திறமையாக இன்டெக்ஸ் செய்து வினவ முடியும், இது பல செயலாக்க பைப்லைன்கள் பகிரப்பட்ட தரவில் இணையாக வேலை செய்ய அனுமதிக்கிறது.
• கூட்டுத் திருத்தம் & IDE-கள்: ஆன்லைன் கூட்டு ஆவண எடிட்டர்கள் அல்லது கிளவுட் அடிப்படையிலான IDE-களில், ஒரு பகிரப்பட்ட ட்ரை நிகழ்நேர தொடரியல் சரிபார்ப்பு, குறியீடு நிறைவு, அல்லது எழுத்துப்பிழை சரிபார்ப்புக்கு சக்தி அளிக்க முடியும், இது வெவ்வேறு நேர மண்டலங்களிலிருந்து பல பயனர்கள் மாற்றங்களைச் செய்யும்போது உடனடியாகப் புதுப்பிக்கப்படும். பகிரப்பட்ட ட்ரை அனைத்து செயலில் உள்ள எடிட்டிங் அமர்வுகளுக்கும் ஒரு நிலையான பார்வையை வழங்கும்.
• கேமிங் & சிமுலேஷன்: உலாவி அடிப்படையிலான மல்டிபிளேயர் கேம்களுக்கு, ஒரு கன்கரென்ட் ட்ரை விளையாட்டுக்குள் அகராதித் தேடல்களை (வார்த்தை விளையாட்டுகளுக்கு), வீரர் பெயர் இன்டெக்ஸ்கள், அல்லது ஒரு பகிரப்பட்ட உலக நிலையில் AI பாதை கண்டுபிடிப்புத் தரவைக் கூட நிர்வகிக்க முடியும், இது அனைத்து விளையாட்டுத் திரிகளும் பதிலளிக்கக்கூடிய விளையாட்டுக்கு நிலையான தகவலில் செயல்படுவதை உறுதி செய்கிறது.
• உயர் செயல்திறன் நெட்வொர்க் பயன்பாடுகள்: பெரும்பாலும் சிறப்பு வன்பொருள் அல்லது குறைந்த-நிலை மொழிகளால் கையாளப்பட்டாலும், ஒரு ஜாவாஸ்கிரிப்ட் அடிப்படையிலான சர்வர் (Node.js) ஒரு கன்கரென்ட் ட்ரை-ஐ டைனமிக் ரூட்டிங் டேபிள்கள் அல்லது நெறிமுறை பாகுபடுத்தலை திறமையாக நிர்வகிக்கப் பயன்படுத்தலாம், குறிப்பாக நெகிழ்வுத்தன்மை மற்றும் விரைவான வரிசைப்படுத்தலுக்கு முன்னுரிமை அளிக்கப்படும் சூழல்களில்.

இந்த எடுத்துக்காட்டுகள் கணினி ரீதியாகத் தீவிரமான சரம் செயல்பாடுகளை பின்னணித் திரிகளுக்கு ஆஃப்லோட் செய்வது, அதே நேரத்தில் ஒரு கன்கரென்ட் ட்ரை மூலம் தரவு ஒருமைப்பாட்டைப் பராமரிப்பது, உலகளாவிய கோரிக்கைகளை எதிர்கொள்ளும் பயன்பாடுகளின் பதிலளிக்கும் தன்மை மற்றும் அளவிடுதலை வியத்தகு முறையில் எவ்வாறு மேம்படுத்தும் என்பதைக் காட்டுகின்றன.

ஜாவாஸ்கிரிப்டில் ஒருங்கிணைப்பின் எதிர்காலம்

ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்பின் நிலப்பரப்பு தொடர்ந்து உருவாகி வருகிறது:

• WebAssembly மற்றும் பகிரப்பட்ட நினைவகம்: WebAssembly மாட்யூல்களும் SharedArrayBuffer-களில் செயல்படலாம், இது CPU-சார்ந்த பணிகளுக்கு இன்னும் நுண்ணிய கட்டுப்பாடு மற்றும் சாத்தியமான உயர் செயல்திறனை வழங்குகிறது, அதே நேரத்தில் ஜாவாஸ்கிரிப்ட் வெப் வொர்க்கர்களுடன் தொடர்பு கொள்ளவும் முடியும்.
• ஜாவாஸ்கிரிப்ட் பிரிமிட்டிவ்களில் மேலும் முன்னேற்றங்கள்: ECMAScript தரநிலை ஒருங்கிணைப்புப் பிரிமிட்டிவ்களை தொடர்ந்து ஆராய்ந்து செம்மைப்படுத்துகிறது, இது பொதுவான ஒருங்கிணைந்த பேட்டர்ன்களை எளிதாக்கும் உயர்-நிலை சுருக்கங்களை சாத்தியமாக வழங்கலாம்.
• நூலகங்கள் மற்றும் கட்டமைப்புகள்: இந்த குறைந்த-நிலை பிரிமிட்டிவ்கள் முதிர்ச்சியடையும்போது, SharedArrayBuffer மற்றும் Atomics-இன் சிக்கல்களைச் சுருக்கும் நூலகங்கள் மற்றும் கட்டமைப்புகள் வெளிப்படும் என்று நாம் எதிர்பார்க்கலாம், இது டெவலப்பர்கள் நினைவக நிர்வாகத்தைப் பற்றிய ஆழமான அறிவு இல்லாமல் ஒருங்கிணைந்த தரவுக் கட்டமைப்புகளை உருவாக்குவதை எளிதாக்கும்.

இந்த முன்னேற்றங்களைத் தழுவுவது ஜாவாஸ்கிரிப்ட் டெவலப்பர்களை சாத்தியமானவற்றின் எல்லைகளைத் தள்ள அனுமதிக்கிறது, உலகளாவிய ரீதியில் இணைக்கப்பட்ட உலகின் கோரிக்கைகளுக்கு ஈடுகொடுக்கக்கூடிய உயர் செயல்திறன் மற்றும் பதிலளிக்கக்கூடிய வலைப் பயன்பாடுகளை உருவாக்குகிறது.

முடிவுரை

ஒரு அடிப்படை ட்ரை-யிலிருந்து ஜாவாஸ்கிரிப்டில் ஒரு முழுமையான த்ரெட்-பாதுகாப்பான கன்கரென்ட் ட்ரை-க்குச் செல்லும் பயணம், மொழியின் நம்பமுடியாத பரிணாமத்திற்கும், அது இப்போது டெவலப்பர்களுக்கு வழங்கும் சக்திக்கும் ஒரு சான்றாகும். SharedArrayBuffer மற்றும் Atomics-ஐப் பயன்படுத்துவதன் மூலம், நாம் ஒற்றைத்-திரி மாதிரியின் வரம்புகளுக்கு அப்பால் சென்று, ஒருமைப்பாடு மற்றும் உயர் செயல்திறனுடன் சிக்கலான, ஒருங்கிணைந்த செயல்பாடுகளைக் கையாளக்கூடிய தரவுக் கட்டமைப்புகளை உருவாக்க முடியும்.

இந்த அணுகுமுறை அதன் சவால்கள் இல்லாமல் இல்லை - இது நினைவக தளவமைப்பு, அணு செயல்பாட்டு வரிசைமுறை, மற்றும் வலுவான பிழை கையாளுதல் ஆகியவற்றில் கவனமான பரிசீலனையைக் கோருகிறது. இருப்பினும், பெரிய, மாற்றக்கூடிய சரம் தரவுத்தொகுப்புகளைக் கையாளும் மற்றும் உலகளாவிய அளவிலான பதிலளிப்பு தேவைப்படும் பயன்பாடுகளுக்கு, கன்கரென்ட் ட்ரை ஒரு சக்திவாய்ந்த தீர்வை வழங்குகிறது. இது டெவலப்பர்களுக்கு அடுத்த தலைமுறை உயர் அளவிடக்கூடிய, ஊடாடும், மற்றும் திறமையான பயன்பாடுகளை உருவாக்க அதிகாரம் அளிக்கிறது, அடிப்படை தரவுச் செயலாக்கம் எவ்வளவு சிக்கலானதாக மாறினாலும் பயனர் அனுபவங்கள் தடையின்றி இருப்பதை உறுதி செய்கிறது. ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்பின் எதிர்காலம் இங்கே உள்ளது, மற்றும் கன்கரென்ட் ட்ரை போன்ற கட்டமைப்புகளுடன், அது முன்னெப்போதையும் விட மிகவும் உற்சாகமாகவும் திறமையாகவும் உள்ளது.